package lanqiao.dontaiguihua.dfs;
//地宫寻宝
import java.util.Scanner;
public class Lan216 {
    static long[][][][] dp=new long[50][50][15][15];
    static int n,m,k;
    static int[][] a;
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        k=sc.nextInt();
        a=new int[n][m];
        initarray();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                a[i][j]=sc.nextInt();
            }
        }
        System.out.println(dfs(0,0,-1,0));
        sc.close();
    }

    public static long dfs(int i,int j,int max,int item){
        if(dp[i][j][max+1][item]!=-1){//如果有可用的方案直接调用可用的方案值;
            return dp[i][j][max+1][item];
        }
        if(i==n-1&&j==m-1){
            if(item==k||(a[i][j]>max&&item==k-1)){
                return 1;
            }
            return 0;
        }
        if(i>=n||j>=m||item>k){
            return 0;
        }
        long r=0;

        if(a[i][j]>max){
            r+=dfs(i+1,j,a[i][j],item+1);//下拿
            r+=dfs(i+1,j,max,item);
            r+=dfs(i,j+1,a[i][j],item+1);
            r+=dfs(i,j+1,max,item);
        }else{
            r+=dfs(i+1,j,max,item);
            r+=dfs(i,j+1,max,item);
        }
        dp[i][j][max+1][item]=r%1000000007;

        return r%1000000007;
    }
    public static void initarray(){
        for(int i=0;i<50;i++){
            for(int j=0;j<50;j++){
                for(int o=0;o<15;o++){
                    for(int k=0;k<15;k++){
                        dp[i][j][o][k]=-1;
                    }
                }
            }
        }
    }

}
/*
这一题算是我遇到的最难的dfs的题,也是第一次认识到记忆化数组,这题思路的关键点在于,dfs里的四个判断,第一个dp[i][j][max+1][item]!=-1,这是为了看是否已经有
可以用的方案数,第二个i==n-1&&j==m-1,这是为了判断是否在出口前一个格子,如果符合该判断,并且符合item==k||(a[i][j]>max&&item==k-1),返回1个方案,对于整个大的
dfs,是不会触发的只有,在递归的并且符合条件的才能触发,所以最后整个大的dfs会返回所有递归加起来的r%100000007*/
